{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 逻辑回归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1、引入相关的库\n",
    "* numpy ：是用Python进行科学计算的基本软件包。\n",
    "* h5py：是与H5文件中存储的数据集进行交互的常用软件包。\n",
    "* matplotlib：是一个著名的库，用于在Python中绘制图表。\n",
    "* lr_utils ：在本文的资料包里，一个加载资料包里面的数据的简单功能的库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py \n",
    "from lr_utils import load_dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* train_set_x_orig ：保存的是训练集里面的图像数据（本训练集有209张64x64的图像）。\n",
    "* train_set_y_orig ：保存的是训练集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。\n",
    "* test_set_x_orig ：保存的是测试集里面的图像数据（本训练集有50张64x64的图像）。\n",
    "* test_set_y_orig ： 保存的是测试集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。\n",
    "* classes ： 保存的是以bytes类型保存的两个字符串数据，数据为：[b’non-cat’ b’cat’]。\n",
    "<br/>现在我们就要把这些数据加载到主程序里面："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2、加载数据到主程序里面"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3、打印图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x20bf9f5b320>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 显示库中第25张图片图片\n",
    "index = 25\n",
    "plt.imshow(train_set_x_orig[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4、打印出当前的训练标签值\n",
    "* 使用np.squeeze的目的是压缩维度，【未压缩】train_set_y[:,index]的值为[1] , 【压缩后】np.squeeze(train_set_y[:,index])的值为1\n",
    "* print(\"【使用np.squeeze：\" + str(np.squeeze(train_set_y[:,index])) + \"，不使用np.squeeze： \" + str(train_set_y[:,index]) + 只有压缩后的值才能进行解码操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y=[1], it's a cat' picture\n"
     ]
    }
   ],
   "source": [
    "print(\"y=\" + str(train_set_y[:,index]) + \", it's a \" + \n",
    "      classes[np.squeeze(train_set_y[:,index])].decode(\"utf-8\") + \"' picture\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5、加载图像数据集具体情况"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对以下参数做出解释：\n",
    "* m_train ：训练集里图片的数量。\n",
    "* m_test ：测试集里图片的数量。\n",
    "* num_px ： 训练、测试集里面的图片的宽度和高度（均为64x64）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集的数量: m_train = 209\n",
      "测试集的数量 : m_test = 50\n",
      "每张图片的宽/高 : num_px = 64\n",
      "每张图片的大小 : (64, 64, 3)\n",
      "训练集_图片的维数 : (209, 64, 64, 3)\n",
      "训练集_标签的维数 : (1, 209)\n",
      "测试集_图片的维数: (50, 64, 64, 3)\n",
      "测试集_标签的维数: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "m_train = train_set_y.shape[1] #训练集里图片的数量。\n",
    "m_test = test_set_y.shape[1] #测试集里图片的数量。\n",
    "num_px = train_set_x_orig.shape[1] #训练、测试集里面的图片的宽度和高度（均为64x64）。\n",
    "\n",
    "''' 现在看一看我们加载的东西的具体情况 '''\n",
    "print (\"训练集的数量: m_train = \" + str(m_train))\n",
    "print (\"测试集的数量 : m_test = \" + str(m_test))\n",
    "print (\"每张图片的宽/高 : num_px = \" + str(num_px))\n",
    "print (\"每张图片的大小 : (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"训练集_图片的维数 : \" + str(train_set_x_orig.shape))\n",
    "print (\"训练集_标签的维数 : \" + str(train_set_y.shape))\n",
    "print (\"测试集_图片的维数: \" + str(test_set_x_orig.shape))\n",
    "print (\"测试集_标签的维数: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6、重新构造样本的维度\n",
    "这一段意思是指把数组变为209行的矩阵（因为训练集里有209张图片），于是我就用-1告诉程序你帮我算有多少列，最后程序算出来时**12288**列，**再最后用一个T表示转置，这就变成了12288行，209列**。测试集亦如此。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#X_flatten = X.reshape(X.shape [0]，-1).T ＃X.T是X的转置\n",
    "#将训练集的维度降低并转置。\n",
    "train_set_x_flatten  = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "#将测试集的维度降低并转置。\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7、查看降维之后的情况"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集降维最后的维度： (12288, 209)\n",
      "训练集_标签的维数 : (1, 209)\n",
      "测试集降维之后的维度: (12288, 50)\n",
      "测试集_标签的维数 : (1, 50)\n"
     ]
    }
   ],
   "source": [
    "print (\"训练集降维最后的维度： \" + str(train_set_x_flatten.shape))\n",
    "print (\"训练集_标签的维数 : \" + str(train_set_y.shape))\n",
    "print (\"测试集降维之后的维度: \" + str(test_set_x_flatten.shape))\n",
    "print (\"测试集_标签的维数 : \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8、标准化数据集\n",
    "标准化后的数据位于[0,1]之间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten / 255\n",
    "test_set_x = test_set_x_flatten / 255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9、构建sigmoid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    参数：\n",
    "        z  - 任何大小的标量或numpy数组。\n",
    "    \n",
    "    返回：\n",
    "        s  -  sigmoid（z）\n",
    "    \"\"\"\n",
    "    s = 1 / (1 + np.exp(-z))\n",
    "    return s\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10、测试sigmoid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================测试sigmoid====================\n",
      "sigmoid(0) = 0.5\n",
      "sigmoid(9.2) = 0.9998989708060922\n"
     ]
    }
   ],
   "source": [
    "print(\"====================测试sigmoid====================\")\n",
    "print (\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print (\"sigmoid(9.2) = \" + str(sigmoid(9.2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11、初始化需要的参数w和b\n",
    "可以执行“前向”和“后向”传播步骤来学习参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "        此函数为w创建一个维度为（dim，1）的0向量，并将b初始化为0。\n",
    "        \n",
    "        参数：\n",
    "            dim  - 我们想要的w矢量的大小（或者这种情况下的参数数量）\n",
    "        \n",
    "        返回：\n",
    "            w  - 维度为（dim，1）的初始化向量。\n",
    "            b  - 初始化的标量（对应于偏差）\n",
    "    \"\"\"\n",
    "    w = np.zeros(shape = (dim,1))\n",
    "    b = 0\n",
    "    #使用断言来确保我要的数据是正确的\n",
    "    assert(w.shape == (dim, 1)) #w的维度是(dim,1)\n",
    "    assert(isinstance(b, float) or isinstance(b, int)) #b的类型是float或者是int\n",
    "    \n",
    "    return (w , b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12、实现计算成本函数及其渐变的函数propagate（）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    实现前向和后向传播的成本函数及其梯度。\n",
    "    参数：\n",
    "        w  - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b  - 偏差，一个标量\n",
    "        X  - 矩阵类型为（num_px * num_px * 3，训练数量）\n",
    "        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据数量)\n",
    "\n",
    "    返回：\n",
    "        cost- 逻辑回归的负对数似然成本\n",
    "        dw  - 相对于w的损失梯度，因此与w相同的形状\n",
    "        db  - 相对于b的损失梯度，因此与b的形状相同\n",
    "    \"\"\"\n",
    "    m = X.shape[1] # 取出X这个ndarry对象中关于形状的第二个参数，也就是样本的总的数量\n",
    "    \n",
    "    #正向传播\n",
    "    A = sigmoid(np.dot(w.T,X) + b) #计算激活值，请参考公式2。\n",
    "    cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) #计算成本，请参考公式3和4。\n",
    "    \n",
    "    #反向传播\n",
    "    dw = (1 / m) * np.dot(X, (A - Y).T) #请参考视频中的偏导公式。\n",
    "    db = (1 / m) * np.sum(A - Y) #请参考视频中的偏导公式。\n",
    "    \n",
    "    #使用断言确保我的数据是正确的\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    #创建一个字典，把dw和db保存起来。\n",
    "    grads = {\n",
    "                \"dw\": dw,\n",
    "                \"db\": db\n",
    "             }\n",
    "    return (grads , cost)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================测试propagate====================\n",
      "dw = [[0.99993216]\n",
      " [1.99980262]]\n",
      "db = 0.49993523062470574\n",
      "cost = 6.000064773192205\n"
     ]
    }
   ],
   "source": [
    "#测试一下propagate\n",
    "print(\"====================测试propagate====================\")\n",
    "#初始化一些参数\n",
    "w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13、使用渐变下降更新参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(w , b , X , Y , num_iterations , learning_rate , print_cost = False):\n",
    "    \"\"\"\n",
    "    此函数通过运行梯度下降算法来优化w和b\n",
    "    \n",
    "    参数：\n",
    "        w  - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b  - 偏差，一个标量\n",
    "        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数组。\n",
    "        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据的数量)\n",
    "        num_iterations  - 优化循环的迭代次数\n",
    "        learning_rate  - 梯度下降更新规则的学习率\n",
    "        print_cost  - 每100步打印一次损失值\n",
    "    \n",
    "    返回：\n",
    "        params  - 包含权重w和偏差b的字典\n",
    "        grads  - 包含权重和偏差相对于成本函数的梯度的字典\n",
    "        成本 - 优化期间计算的所有成本列表，将用于绘制学习曲线。\n",
    "    \n",
    "    提示：\n",
    "    我们需要写下两个步骤并遍历它们：\n",
    "        1）计算当前参数的成本和梯度，使用propagate（）。\n",
    "        2）使用w和b的梯度下降法则更新参数。\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        \n",
    "        grads, cost = propagate(w, b, X, Y)\n",
    "        \n",
    "        ''' 这是初始化方法么？？ '''\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        \n",
    "        #记录成本\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        #打印成本数据\n",
    "        if (print_cost) and (i % 100 == 0):\n",
    "            print(\"迭代的次数: %i ， 误差值： %f\" % (i,cost))\n",
    "        \n",
    "    params  = {\n",
    "                \"w\" : w,\n",
    "                \"b\" : b }\n",
    "    grads = {\n",
    "            \"dw\": dw,\n",
    "            \"db\": db } \n",
    "    return (params , grads , costs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================测试optimize====================\n",
      "w = [[0.1124579 ]\n",
      " [0.23106775]]\n",
      "b = 1.5593049248448891\n",
      "dw = [[0.90158428]\n",
      " [1.76250842]]\n",
      "db = 0.4304620716786828\n"
     ]
    }
   ],
   "source": [
    "#测试optimize\n",
    "print(\"====================测试optimize====================\")\n",
    "w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])\n",
    "params , grads , costs = optimize(w , b , X , Y , num_iterations=100 , learning_rate = 0.009 , print_cost = False)\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 14、实现预测函数 predict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(w , b , X ):\n",
    "    \"\"\"\n",
    "    使用学习逻辑回归参数logistic （w，b）预测标签是0还是1，\n",
    "    \n",
    "    参数：\n",
    "        w  - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b  - 偏差，一个标量\n",
    "        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数据\n",
    "    \n",
    "    返回：\n",
    "        Y_prediction  - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组（向量）\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    m  = X.shape[1] # 图片的数量\n",
    "    Y_prediction = np.zeros((1,m)) \n",
    "    w = w.reshape(X.shape[0],1)\n",
    "    \n",
    "    #计预测猫在图片中出现的概率\n",
    "    A = sigmoid(np.dot(w.T , X) + b)\n",
    "    for i in range(A.shape[1]):\n",
    "        #将概率a [0，i]转换为实际预测p [0，i]\n",
    "        Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0\n",
    "    #使用断言\n",
    "    assert(Y_prediction.shape == (1,m))\n",
    "    \n",
    "    return Y_prediction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================测试predict====================\n",
      "predictions = [[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#测试predict\n",
    "print(\"====================测试predict====================\")\n",
    "w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])\n",
    "print(\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15、将所有的函数整合到model()中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train , Y_train , X_test , Y_test , num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):\n",
    "    \"\"\"\n",
    "    通过调用之前实现的函数来构建逻辑回归模型\n",
    "    \n",
    "    参数：\n",
    "        X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集\n",
    "        Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集\n",
    "        X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集\n",
    "        Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集\n",
    "        num_iterations  - 表示用于优化参数的迭代次数的超参数\n",
    "        learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数\n",
    "        print_cost  - 设置为true以每100次迭代打印成本\n",
    "    \n",
    "    返回：\n",
    "        d  - 包含有关模型信息的字典。\n",
    "    \"\"\"\n",
    "    w , b = initialize_with_zeros(X_train.shape[0])\n",
    "    \n",
    "    parameters , grads , costs = optimize(w , b , X_train , Y_train,num_iterations , learning_rate , print_cost)\n",
    "    \n",
    "    #从字典“参数”中检索参数w和b\n",
    "    w , b = parameters[\"w\"] , parameters[\"b\"]\n",
    "    \n",
    "    #预测测试/训练集的例子\n",
    "    Y_prediction_test = predict(w , b, X_test)\n",
    "    Y_prediction_train = predict(w , b, X_train)\n",
    "    \n",
    "    #打印训练后的准确性\n",
    "    print(\"训练集准确性：\"  , format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100) ,\"%\")\n",
    "    print(\"测试集准确性：\"  , format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100) ,\"%\")\n",
    "    \n",
    "    d = {\n",
    "            \"costs\" : costs,\n",
    "            \"Y_prediction_test\" : Y_prediction_test,\n",
    "            \"Y_prediciton_train\" : Y_prediction_train,\n",
    "            \"w\" : w,\n",
    "            \"b\" : b,\n",
    "            \"learning_rate\" : learning_rate,\n",
    "            \"num_iterations\" : num_iterations }\n",
    "    return d\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实际测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================测试model====================\n",
      "迭代的次数: 0 ， 误差值： 0.693147\n",
      "迭代的次数: 100 ， 误差值： 0.584508\n",
      "迭代的次数: 200 ， 误差值： 0.466949\n",
      "迭代的次数: 300 ， 误差值： 0.376007\n",
      "迭代的次数: 400 ， 误差值： 0.331463\n",
      "迭代的次数: 500 ， 误差值： 0.303273\n",
      "迭代的次数: 600 ， 误差值： 0.279880\n",
      "迭代的次数: 700 ， 误差值： 0.260042\n",
      "迭代的次数: 800 ， 误差值： 0.242941\n",
      "迭代的次数: 900 ， 误差值： 0.228004\n",
      "迭代的次数: 1000 ， 误差值： 0.214820\n",
      "迭代的次数: 1100 ， 误差值： 0.203078\n",
      "迭代的次数: 1200 ， 误差值： 0.192544\n",
      "迭代的次数: 1300 ， 误差值： 0.183033\n",
      "迭代的次数: 1400 ， 误差值： 0.174399\n",
      "迭代的次数: 1500 ， 误差值： 0.166521\n",
      "迭代的次数: 1600 ， 误差值： 0.159305\n",
      "迭代的次数: 1700 ， 误差值： 0.152667\n",
      "迭代的次数: 1800 ， 误差值： 0.146542\n",
      "迭代的次数: 1900 ， 误差值： 0.140872\n",
      "训练集准确性： 99.04306220095694 %\n",
      "测试集准确性： 70.0 %\n"
     ]
    }
   ],
   "source": [
    "print(\"====================测试model====================\")     \n",
    "#这里加载的是真实的数据，请参见上面的代码部分。\n",
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 16、画图表示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#绘制图\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试不同的学习率带来的影响"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learning rate is: 0.01\n",
      "训练集准确性： 99.52153110047847 %\n",
      "测试集准确性： 68.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.001\n",
      "训练集准确性： 88.99521531100478 %\n",
      "测试集准确性： 64.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.0001\n",
      "训练集准确性： 68.42105263157895 %\n",
      "测试集准确性： 36.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "for i in learning_rates:\n",
    "    print (\"learning rate is: \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center', shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
